home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 12 / Mac Magazin and MacEasy Magazine CD - Issue 12.iso / Sharewarebibliothek / Anwendungen / Grafik / Matt's_Fract(Fat)101 / Sources / fractal.c next >
C/C++ Source or Header  |  1995-07-10  |  27KB  |  1,336 lines
  1. #include "AllTools.h"
  2. #include "fractal.h"
  3.  
  4. #define NIL_POINTER       0L
  5. #define REMOVE_ALL_EVENTS 0
  6.  
  7. #define    mrBlob1    ((x >> 8) & 255) + (y & 65280)
  8. #define    mrBlob2    ((x >> 8) & 254) + (y & 65024)
  9. #define    mrBlob3    ((x >> 8) & 252) + (y & 64512)
  10. #define heightShift 7
  11.  
  12. void     Maketables(void);
  13. void     ToolBoxInit(void);
  14. void     WindowInit(void);
  15. void    MemInit(void);
  16. void    MemEnd(void);
  17. void     FillWindowBlack(WindowPtr theWindow);
  18. void    WindowMove(void);
  19. void     clearOffScreen(void);
  20. void    copyOffScreen(void);
  21. void     ToDrawX1(void);
  22. void     ToDrawX2(void);
  23. void     ToDrawX4(void);
  24.  
  25. void     DoPreferences(void);
  26. void    MakeMap(void);
  27. void     ChangeHeight( int pss, int height );
  28. void    Smooth(int pss);
  29. void     MakeCols(void);
  30. void     BlurMap(void);
  31. void    Quit(void);
  32. int        hght(short x, short y);
  33. int     hght2(short x, short y);
  34. void    fixVars(void);
  35. long     myRnd(long    range);
  36.  
  37.  
  38. typedef struct
  39.     {
  40.         unsigned char    map[256][256];
  41.     }  MAP, *mapPeek;
  42.  
  43. typedef struct
  44.     {
  45.         unsigned long    colorGrid[256][512];
  46.     } aCol,    *aColPeek;
  47.  
  48. WindowPtr             EliteWindow, theGameWindow;
  49. Rect                theGameRect;
  50. PaletteHandle        fracCols;
  51. Ptr                    offScreen;
  52. Ptr theTemp, theTemp2, theTemp3;
  53. videoInfo    theScreen;
  54. Ptr ScrnBase;
  55. long    hhhh, xxxx,yyyy;;
  56. long    mapX, mapY, initPss, mapXp, mapYp;
  57. long    windX, windY, rayLen, xStep, yStep, windX2, windY2, windX4, windXstep, windYsteps, yOffSet;
  58. long    cs[2560], sn[2560], angle;
  59. long    theSize;
  60. long    rBts, xres2, yres2, orfset;
  61. unsigned short    mx, my;
  62. long    mx2, my2;
  63. long    randSeed, waterLevel;
  64. Boolean    shade, endIt;
  65. unsigned long    sky;
  66. long    velocity;
  67. short    pNum;
  68. mapPeek    the, the2;
  69. aColPeek the3;
  70. short    oldBitDepth;
  71. long    tempHeight;
  72.  
  73. short    RayLengthOption, PixelSizeOption, LandScapeOption, WindowSizeOption;
  74. main()
  75. {
  76. MbarInit();
  77.  
  78. RayLengthOption = 1;
  79. PixelSizeOption = 1;
  80. LandScapeOption = 1;
  81. WindowSizeOption = 1;
  82.  
  83. pNum    =    2;
  84. angle    =    0;
  85. mapX    =    256;
  86. mapY    =    256;
  87. initPss    =    64;
  88.  
  89. windX     =     256;
  90. windY     =     192;
  91. rayLen    =    511;
  92. xStep    =    4;
  93. yStep    =    2;
  94. shade    =    TRUE;
  95. randSeed=    2;
  96. waterLevel=    0;
  97.  
  98. yOffSet    =    64;
  99.  
  100. velocity = 256;
  101.  
  102. sky        =    (unsigned long)2;
  103. sky        =    (sky | (sky << 8));
  104. sky        =    (sky | (sky << 8));
  105. sky        =    (sky | (sky << 8));
  106.  
  107. mapX    =    256;
  108. mapY    =    256;
  109. initPss    =    64;
  110. mapXp    =    mapX - 1;
  111. mapYp    =    mapY - 1;
  112.  
  113. xxxx    =    0;
  114. yyyy    =    0;
  115.  
  116.  
  117.     ToolBoxInit();
  118.     WindowInit();
  119.     MemInit();
  120.     Maketables();
  121.  
  122. fixVars();
  123.  
  124. endIt = TRUE;
  125.         HideMenuBar();
  126.     while(TRUE)
  127.     {
  128.         DoPreferences();
  129.         fixVars();
  130.         WindowMove();
  131.     
  132.             
  133.         MakeMap();
  134.         BlurMap();
  135.         MakeCols();
  136.         
  137.         clearOffScreen();
  138.         
  139. hhhh = ((long)(the->map[(short)((yyyy >> 8) & 255)][(short)((xxxx >> 8) & 255)] + 16) << heightShift);
  140.  
  141.             while(!Button())
  142.             {
  143.                 mx = getCursorX();
  144.                 mx2 = (long)mx;
  145.         
  146.                 my = getCursorY();
  147.                 my2 = (long)my;
  148.         
  149.                     angle = angle - ((xres2 - mx2) >> 3);
  150.                     if ( angle > 2559 ) angle = angle - 2560;
  151.                     if ( angle <   0 ) angle = angle + 2560;
  152.                     
  153.                     hhhh = hhhh - ((yres2 - my2));
  154.                     yOffSet = ((yres2 - my2) >> 1);
  155.                     
  156.                     if ((*(long*)(0x174)) == 1) velocity = velocity + 16;
  157.                     if ((*(long*)(0x174)) == 8) velocity = velocity - 16;
  158.                     
  159.                     xxxx = xxxx + ((cs[angle] * velocity) >> 8);
  160.                     yyyy = yyyy + ((sn[angle] * velocity) >> 8);
  161.                     
  162. tempHeight = ((long)(the->map[(short)((yyyy >> 8) & 255)][(short)((xxxx >> 8) & 255)] + 16) << heightShift);
  163. if (hhhh < tempHeight) hhhh = tempHeight;
  164.                     
  165.                 if (xStep == 1) ToDrawX1();
  166.                 if (xStep == 2) ToDrawX2();
  167.                 if (xStep == 4) ToDrawX4();
  168.             }
  169.     }
  170. }
  171.  
  172. void fixVars(void)
  173. {
  174.     angle    =    0;
  175.     rBts    =    (long)(theScreen.rowBytes);
  176.     xres2    =    (long)((theScreen.resolutionX) >> 1);
  177.     yres2    =    (long)((theScreen.resolutionY) >> 1);
  178.     theSize    =    windX * windY;
  179.     orfset    = (xres2 - windX) + ((yres2 - windY) * rBts);
  180.     windX2    =    windX << 1;
  181.     windY2    =    windY << 1;
  182.     windX4    =    windX2 << 1;
  183.     windYsteps = windY2 / yStep;
  184.     windXstep = yStep * windX2;
  185.     velocity = 512;
  186. }
  187.  
  188. void Maketables(void)
  189. {
  190. long    cnt;
  191. float    num;
  192.     
  193. long colr, shady, depth;
  194. long colorPtr;
  195. long shaded, shaded2;
  196.  
  197. for (cnt = 0; cnt < 2560; cnt = cnt + 1)
  198.     {
  199.     num    = (float)cnt * 0.00245436926062;
  200.     cs[cnt] = (long)(cos(num) * 256);
  201.     sn[cnt] = (long)(sin(num) * 256);
  202.     }
  203.     
  204. theTemp3 = NewPtr( 527364 );
  205. if (theTemp3 == 0) ExitToShell();
  206. the3 = (aColPeek)theTemp3;
  207.  
  208. for (colr = 0;colr < 16; colr++)
  209. {
  210.     for (shady = 0;shady<16; shady++)
  211.     {
  212.         colorPtr = ((colr << 4) + shady);
  213.         for (depth = 0;depth < 512; depth ++)
  214.         {
  215.             shaded = ((shady << 2) - ((shady  * depth) >> 7));
  216.             shaded2 = shaded & 1;
  217.             shaded = shaded >> 1;
  218.             shaded2 = shaded2 + shaded;
  219.             if (shaded2 > 31) shaded2 = 31;
  220.             shaded = (shaded + (colr * 32));
  221.             
  222.             shaded2 = (shaded2 + (colr * 32));
  223.             
  224.             shaded = shaded + (shaded2 << 8);
  225.             shaded = shaded + (shaded << 16);
  226.             the3->colorGrid[(short)colorPtr][(short)depth] = (unsigned long)shaded;
  227.         }
  228.     }
  229. }
  230.  
  231. }
  232.  
  233. void ToolBoxInit(void)
  234. {
  235.     InitGraf(&qd.thePort);
  236.     InitFonts();
  237.     FlushEvents(everyEvent, REMOVE_ALL_EVENTS);
  238.     InitWindows();
  239.     InitMenus();
  240.     TEInit();
  241.     InitDialogs(NIL_POINTER);
  242.     InitCursor();
  243.     
  244.     theScreen = GetVideoInfo();
  245.     ScrnBase = theScreen.screenBase;
  246. }
  247.  
  248. void WindowInit(void)
  249. {
  250. DialogPtr    dialog;
  251. Boolean    itsDone;
  252. short    itemHit;
  253.  
  254. oldBitDepth = theScreen.bitsPerPixel;
  255.  
  256.     if (theScreen.BitDepthPossible[8] == FALSE) DoError( 17, TRUE);
  257.  
  258.     if ((theScreen.bitsPerPixel != 8) && (theScreen.BitDepthPossible[8] == TRUE))
  259.                             {
  260.                                 SysBeep(1);
  261.                                 dialog = GetNewDialog(132, nil, (WindowPtr)-1);
  262.                                 CenterDialog(dialog, theScreen);
  263.                                 DrawDialog(dialog);
  264.                                 
  265. itsDone = FALSE;
  266. FlushEvents(everyEvent, REMOVE_ALL_EVENTS);
  267.             while(!itsDone)
  268.             {
  269.                 ModalDialog(nil, &itemHit);
  270.                 if (itemHit == 1)     {
  271.                                     ChangeBitDepth(8,1);
  272.                                     theScreen = GetVideoInfo();
  273.                                     itsDone = TRUE;
  274.                                     }
  275.                                     
  276.                 if (itemHit == 2)     {
  277.                                     ExitToShell();
  278.                                     }
  279.                             }
  280.             }    
  281.     EliteWindow = NewCWindow( 0L, &theScreen.screenRect, "\pFractal", TRUE, plainDBox, ( WindowPtr ) -1, FALSE, 0L );
  282.     SelectWindow(EliteWindow);
  283.     SetPort(EliteWindow);
  284.     
  285. SetRect(&theGameRect, 0, 0, (windX << 1), (windY << 1));
  286.  
  287.     theGameWindow = NewCWindow(nil, &theGameRect, "\pFractal", TRUE, 1, (WindowPtr)-1, FALSE, 0);
  288.     MoveWindow(theGameWindow,     (theScreen.resolutionX >>1) - windX, 
  289.                                 (theScreen.resolutionY >>1) - windY, FALSE);
  290.  
  291.     FillWindowBlack(EliteWindow);
  292.  
  293.     SetPort(theGameWindow);
  294.     SelectWindow(theGameWindow);
  295.     SelectWindow(theGameWindow);
  296.  
  297.     FillWindowBlack(theGameWindow);
  298.  
  299.     fracCols = GetNewPalette( (127+pNum) );
  300. }
  301.  
  302. void    WindowMove(void)
  303. {
  304.     qd.randSeed = randSeed;
  305.     
  306.     SelectWindow(EliteWindow);
  307.     SetPort(EliteWindow);
  308.     
  309.     SetRect(&theGameRect, 0, 0, (windX << 1), (windY << 1));
  310.     SizeWindow(theGameWindow, (windX << 1), (windY << 1), TRUE);
  311.  
  312.     MoveWindow(theGameWindow,     (theScreen.resolutionX >>1) - windX, 
  313.                                 (theScreen.resolutionY >>1) - windY, FALSE);
  314.  
  315.     DisposePalette(fracCols);
  316.     fracCols = GetNewPalette( (127 + pNum) );
  317.     SetPalette( EliteWindow, fracCols, TRUE );
  318.     SetPalette( theGameWindow, fracCols, TRUE );
  319.     
  320.     FillWindowBlack(EliteWindow);
  321.     FillWindowBlack(theGameWindow);
  322.  
  323.     SetPort(theGameWindow);
  324.     SelectWindow(theGameWindow);
  325.     SelectWindow(theGameWindow);
  326. }
  327.  
  328. void MemInit(void)
  329. {
  330. Size    ScSize;
  331.  
  332. ScSize = (Size)(((long)640) * ((long)480));
  333.     theTemp        =     NewPtr( 66049);
  334.     if (theTemp == 0) DoError(6, TRUE);
  335.     theTemp2    =     NewPtr( 66049);
  336.     if (theTemp2 == 0) DoError(6, TRUE);
  337.     offScreen    =    NewPtr( (long)ScSize );
  338.     if (offScreen == 0) DoError(6, TRUE);
  339.     
  340.     the = (mapPeek)theTemp;
  341.     the2 = (mapPeek)theTemp2;
  342. }
  343.  
  344. void    MemEnd(void)
  345. {
  346.     DisposPtr(theTemp);
  347.     DisposPtr(theTemp2);
  348.     DisposPtr(offScreen);
  349. }
  350.  
  351. void FillWindowBlack(WindowPtr theWindow)
  352. {
  353.     SetPort(EliteWindow);
  354.     ForeColor( blackColor );
  355.     PaintRect( &EliteWindow->portRect );
  356.     SetPort(theGameWindow);
  357.     ForeColor( blackColor );
  358.     PaintRect( &theGameWindow->portRect );
  359. }
  360.  
  361. void MakeMap(void)
  362. {
  363.     short     pss,height;
  364.     short        x,y;
  365.     
  366.     DialogPtr    dialog;
  367.     
  368.     dialog = GetNewDialog(129, nil, (WindowPtr)-1);
  369.     CenterDialog(dialog, theScreen);
  370.     DrawDialog(dialog);
  371.     FillWindowBlack(EliteWindow);
  372.  
  373.     qd.randSeed = randSeed;
  374.         
  375.     pss =        initPss;
  376.     height =    128;
  377.     
  378.     for( y = 0; y < mapY; y++ )
  379.     {
  380.         for( x = 0; x < mapX; x++ )
  381.         {
  382.             the->map[x][y] = 0;
  383.         }
  384.     }
  385.     
  386.     while(pss > 4)
  387.     {
  388.         ChangeHeight( pss, height );
  389.         Smooth(pss);
  390.         pss = pss >> 1;
  391.         height = height >> 1;
  392.         if (height == 0) height = 1;
  393.     }
  394.     
  395.     while(pss > 1)
  396.     {
  397.         Smooth(pss);
  398.         pss = pss >> 1;
  399.     }
  400.     
  401.     DisposDialog(dialog);
  402. }
  403.  
  404. void ChangeHeight( int pss, int height )
  405. {
  406.     long            x,y;
  407.     unsigned char    c;
  408.  
  409.     for ( x = 0; x < mapX; x = x + pss )
  410.     {
  411.         for( y = 0; y < mapY; y = y + pss )
  412.         {
  413.             c = the->map[x][y] + (Random() / (32768 / height)) ;
  414.             the->map[x][y] = c;
  415.         }
  416.     }
  417.     
  418. }
  419.  
  420. void Smooth(int pss)
  421. {
  422.     long        dff;
  423.     short        x,y;
  424.     long        c;
  425.     long    misc;
  426.  
  427.     dff = pss>>1;
  428.     for ( x = 0; x < mapX; x = x + pss )
  429.     {
  430.         for( y = 0; y < mapY; y = y + pss )
  431.         {    
  432.         
  433.     misc = (long)((long)hght(x,y) + (long)hght(x + pss,y) + (long)hght(x + pss,y + pss) + (long)hght(x,y + pss));
  434.     
  435.     the->map[x+dff][y+dff] = (unsigned char)(misc >> 2);
  436.     
  437.     c = (hght(x,y) + hght(x+pss,y))>> 1;
  438.     the->map[x+dff][y] = c;
  439.     
  440.     c = (hght(x,y) + hght(x,y+pss))>> 1;
  441.     the->map[x][y+dff] = c;
  442.     
  443.     c = ((long)((hght(x+pss,y+pss) + hght(x+pss,y))))>>1;
  444.     the->map[x+pss][y+dff] = c;
  445.     
  446.     c = (hght(x+pss,y+pss) + hght(x,y+pss))>>1;
  447.     the->map[x+dff][y+pss] = c;
  448.             
  449.         }
  450.     }
  451. }
  452.  
  453. int hght(short x, short y)
  454. {
  455.  
  456. return (unsigned char)the->map[x & mapXp][y & mapYp];
  457. }
  458.  
  459. int hght2(short x, short y)
  460. {
  461.  
  462. return (unsigned char)the2->map[x & mapXp][y & mapYp];
  463. }
  464.  
  465. void BlurMap(void)
  466. {
  467. long    hht;
  468. short         x,y;
  469. long    min, max, range, mlt;
  470.  
  471.     DialogPtr    dialog;
  472.     
  473.     dialog = GetNewDialog(130, nil, (WindowPtr)-1);
  474.     CenterDialog(dialog, theScreen);
  475.     DrawDialog(dialog);
  476.     FillWindowBlack(EliteWindow);
  477.     
  478. min = 255;
  479. max = 0;
  480.  
  481. for(x = 0; x < mapX; x++)
  482.     {
  483.         for(y = 0; y < mapY; y++)
  484.             {
  485.                 hht = the->map[x][y];
  486.                 the2->map[x][y] = hht;
  487.                 if (hht > max) max = hht;
  488.                 if (hht < min) min = hht;
  489.             }
  490.     }
  491.  
  492. range = max - min;
  493. mlt = 255/ range;
  494.  
  495. for(x = 0; x < mapX; x++)
  496.     {
  497.         for(y = 0; y < mapY; y++)
  498.             {
  499.                 hht = the->map[x][y];
  500.                 hht = hht - min;
  501.                 
  502.                 hht = hht - waterLevel;
  503.                 if (hht < 0) hht = 0;
  504.                 the2->map[x][y] = hht;
  505.             }
  506.     }
  507.  
  508. for(x = 0; x < mapX; x++)
  509.     {
  510.         for(y = 0; y < mapY; y++)
  511.             {
  512.                 hht = (long)(((long)hght2(x+6,y-4)) << 2) + (((long)hght2(x-4,y+8)) << 2) + ((long)(hght2(x,y)) << 3);
  513.                 the->map[x][y] = (unsigned char)(hht >> 5);
  514.             }
  515.     }
  516.  
  517.     DisposDialog(dialog);
  518. }
  519.  
  520. long myRnd(long    range)
  521. {
  522.  
  523. return (Random() / 65536) * range;
  524. }
  525.  
  526. void MakeCols(void)
  527. {
  528.     short    x, y, c, co;
  529.     
  530.     DialogPtr    dialog;
  531.     
  532.     dialog = GetNewDialog(131, nil, (WindowPtr)-1);
  533.     CenterDialog(dialog, theScreen);
  534.     DrawDialog(dialog);
  535.     FillWindowBlack(EliteWindow);
  536.     
  537.     for( y = 0; y < mapX; y++)
  538.     {
  539.         for( x = 0; x < mapY; x++)
  540.         {
  541.             c = (short)((unsigned char)the->map[x][y]);
  542.             co = c;
  543.                 c = (short)( ((long)(c - 
  544.                             ((unsigned char)the->map
  545.                                 [((short)(x + 3) & mapXp)]
  546.                                 [((short)(y + 3) & mapYp)])
  547.                         )) << 2 );
  548.                  c = (short)(((long)c) >> 3);
  549.                  c = c + 7;
  550.                  if (c > 15) c = 15;
  551.                  if (c < 0) c = 0;
  552.                  
  553.                  c = c + 32;
  554.                  
  555.                  if (co == 0) c = 47;
  556.                  if (co > 0) c = c + 16;
  557.                  if (co > 16) c = c + 16;
  558.                  if (co > 32) c = c + 16;
  559.                  if (co > 48) c = c + 16;
  560.                                   
  561.                  the2->map[x][y] = (unsigned char)(c);
  562.         }
  563.     }
  564.  
  565.     DisposDialog(dialog);
  566.     FillWindowBlack(EliteWindow);
  567. }
  568.  
  569. void copyOffScreen(void)
  570. {
  571. Ptr    ta0, ta1, ta2;
  572. long td0, td1, td2, td3, td7;    
  573.  
  574. ta0 = offScreen;
  575. ta0 += windXstep;
  576. ta0 -= windX2;
  577. ta1 = ScrnBase;
  578. ta1+= orfset;
  579.  
  580. td1 = windYsteps;
  581. td0 = (windX >> 1);
  582. td0 -= 1;
  583. td1 -= 1;
  584.  
  585. td2 = td0;
  586.  
  587. td3 = rBts - windX2;
  588.  
  589. while(td1 >= 0)
  590.     {
  591.         td7 = yStep - 1;
  592.         
  593.         while(td7 >= 0)
  594.             {
  595.                 td0 = td2;
  596.                 
  597.                 ta2 = ta0 + (4 * td2);
  598.                 
  599.                 while(ta2 >= ta0)
  600.                     {
  601.                         *(unsigned long*)(ta1) = *(unsigned long*)(ta0);
  602.                         ta0 += 4;
  603.                         ta1 += 4;
  604.                     }
  605.                 ta0 -= windX2;
  606.                 ta1 += td3;
  607.                 
  608.                 td7 -= 1;
  609.             }
  610.         ta0 += windXstep;
  611.         td1 -= 1;
  612.     }
  613. }
  614.  
  615. void clearOffScreen(void)
  616. {
  617. Ptr    offScreenCounter;
  618. Ptr    theEndCounter;
  619. unsigned long    skyColour;
  620.  
  621. offScreenCounter = offScreen;
  622. theEndCounter = offScreenCounter + (theSize << 2);
  623. skyColour = sky;
  624.  
  625. while(theEndCounter != offScreenCounter)
  626.     {
  627.         *(unsigned long*)(offScreenCounter) = skyColour;
  628.         offScreenCounter +=4;
  629.     }
  630. }
  631.  
  632. void ToDrawX1(void)
  633. {
  634. long     xp, yp, xp2;
  635. long    L;
  636. long    x, y;
  637. long    xv, zv;
  638. long    z, yv;
  639. Ptr        offScreen2;
  640. unsigned short    MrBlobby;
  641. long    rayLenTmp;
  642. long    xOffSet, xOffSetdiv, xChng, yztemp, yOffSet2;
  643.  
  644. xp     = -windX;
  645. xp2    = 0;
  646. xChng = -((xres2 - mx2) >> 2);
  647. xOffSet = xp * xChng;
  648. xOffSetdiv = xOffSet >> 8;
  649.  
  650. while (xp < windX)
  651.     {
  652.  
  653.     x    =    xxxx;
  654.     y    =    yyyy;
  655.     z    =    hhhh + (xOffSet >> 8);
  656.     yp    =     -windY;
  657.     L    =      1;
  658.     offScreen2 = offScreen + xp2 + (((windY2-1) * windX2));
  659.     
  660.     xv    =    (long)(cs[angle] - ((xp * sn[angle]) >> 8) );
  661.     zv    =    (long)(sn[angle] + ((xp * cs[angle]) >> 8) );
  662.  
  663.     yv    =    yp - yOffSet - (xOffSet >> 8);
  664.     yOffSet2 = - yOffSet - xOffSetdiv;
  665.     
  666.     rayLenTmp = 128;
  667.     if (rayLen < rayLenTmp) rayLenTmp = rayLen;
  668.     MrBlobby = mrBlob1;
  669.     
  670.     while (L<rayLenTmp)
  671.         {
  672.  
  673.         if ( *(theTemp + MrBlobby ) > (z >> heightShift) )
  674.             {
  675.             *(unsigned char*)(offScreen2) = 
  676.             *(unsigned char*)(theTemp3 + (((long)*(theTemp2 + MrBlobby)) << 11) + (L << 2));
  677.             
  678.             offScreen2    -= windXstep;
  679.  
  680.             yp    += yStep;
  681.             yv    += yStep;
  682.  
  683.             z = hhhh + (yv * L);
  684.             if (yp >= windY) goto end1;
  685.             }
  686.             else
  687.             {
  688.                 L++;
  689.                 x += xv;
  690.                 y += zv;
  691.                 z += yv;
  692.                 MrBlobby = mrBlob1;
  693.             }
  694.         }
  695.  
  696.         yv    =    yv << 1;
  697.         xv    =    xv << 1;
  698.         zv    =    zv << 1;
  699.  
  700.         rayLenTmp = 256;
  701.         if (rayLen < rayLenTmp) rayLenTmp = rayLen;
  702.  
  703.         if (yp>=windY) L = rayLenTmp;
  704.         
  705.         while (L<rayLenTmp)
  706.         {
  707.         if ( *(theTemp + MrBlobby ) > (z >> heightShift) )
  708.             {
  709.             *(unsigned short*)(offScreen2) = 
  710.             *(unsigned short*)(theTemp3 + (((long)*(theTemp2 + MrBlobby)) << 11) + (L << 2));
  711.             
  712.             offScreen2    -= windXstep;
  713.  
  714.             yp    += yStep;
  715.             yztemp = yp + yOffSet2;
  716.             yv = yztemp << 1;
  717.             
  718.             z = hhhh + (yztemp * L);
  719.             if (yp>=windY) goto end1;
  720.             }
  721.             else
  722.             {
  723.                 L += 2;
  724.                 x += xv;
  725.                 y += zv;
  726.                 z += yv;
  727.                 MrBlobby = mrBlob1;
  728.             }
  729.         }
  730.         
  731.         yv    =    yv << 1;
  732.         xv    =    xv << 1;
  733.         zv    =    zv << 1;
  734.         
  735.         rayLenTmp = rayLen;
  736.         
  737.         if (yp>=windY) goto end1;
  738.         while (L<rayLenTmp)
  739.         {
  740.  
  741.         if ( *(theTemp + MrBlobby ) > (z >> heightShift) )
  742.             {
  743.             *(unsigned short*)(offScreen2) = 
  744.             *(unsigned short*)(theTemp3 + (((long)*(theTemp2 + MrBlobby)) << 11) + (L << 2));
  745.             
  746.             offScreen2    -= windXstep;
  747.             yp += yStep;
  748.             
  749.             yztemp = yp + yOffSet2;
  750.             yv    =    yztemp << 2;
  751.             
  752.             z = hhhh + (yztemp * L);
  753.             if (yp>=windY) L = rayLenTmp;
  754.             }
  755.             else
  756.             {
  757.                 L += 4;
  758.                 x += xv;
  759.                 y += zv;
  760.                 z += yv;
  761.                 MrBlobby = mrBlob1;
  762.             }
  763.         }
  764.         
  765.     end1:
  766.     xp2    += 1;
  767.     xp    += 1;
  768.     xOffSet += xChng;
  769.     xOffSetdiv = xOffSet >> 8;
  770.     }
  771.     copyOffScreen();
  772.     clearOffScreen();
  773. }
  774.  
  775. void ToDrawX2(void)
  776. {
  777. long     xp, yp, xp2;
  778. long    L;
  779. long    x, y;
  780. long    xv, zv;
  781. long    z, yv;
  782. Ptr        offScreen2;
  783. unsigned short    MrBlobby;
  784. long    rayLenTmp;
  785. long    xOffSet, xOffSetdiv, xChng, yztemp, yOffSet2;
  786.  
  787. xp     = -windX;
  788. xp2    = 0;
  789. xChng = -((xres2 - mx2) >> 2);
  790. xOffSet = xp * xChng;
  791. xOffSetdiv = xOffSet >> 8;
  792. xChng = xChng << 1;
  793.  
  794. while (xp < windX)
  795.     {
  796.  
  797.     x    =    xxxx;
  798.     y    =    yyyy;
  799.     z    =    hhhh + (xOffSet >> 8);
  800.     yp    =     -windY;
  801.     L    =      1;
  802.     offScreen2 = offScreen + xp2 + (((windY2-1) * windX2));
  803.     
  804.     xv    =    (long)(cs[angle] - ((xp * sn[angle]) >> 8) );
  805.     zv    =    (long)(sn[angle] + ((xp * cs[angle]) >> 8) );
  806.  
  807.     yv    =    yp - yOffSet - (xOffSet >> 8);
  808.     yOffSet2 = - yOffSet - xOffSetdiv;
  809.     
  810.     rayLenTmp = 128;
  811.     if (rayLen < rayLenTmp) rayLenTmp = rayLen;
  812.         MrBlobby = mrBlob1;    
  813.     while (L<rayLenTmp)
  814.         {
  815.  
  816.         if ( *(theTemp + MrBlobby ) > (z >> heightShift) )
  817.             {
  818.             *(unsigned short*)(offScreen2) = 
  819.             *(unsigned short*)(theTemp3 + (((long)*(theTemp2 + MrBlobby)) << 11) + (L << 2));
  820.             
  821.             offScreen2    -= windXstep;
  822.  
  823.             yp    += yStep;
  824.             yv    += yStep;
  825.             
  826.             z = hhhh + (yv * L);
  827.             if (yp >= windY) goto end2;
  828.             }
  829.             else
  830.             {
  831.                 L++;
  832.                 x += xv;
  833.                 y += zv;
  834.                 z += yv;
  835.                 MrBlobby = mrBlob1;
  836.             }
  837.         }
  838.         
  839.         yv    =    yv << 1;
  840.         xv    =    xv << 1;
  841.         zv    =    zv << 1;
  842.         
  843.         rayLenTmp = 256;
  844.         if (rayLen < rayLenTmp) rayLenTmp = rayLen;
  845.         
  846.         if (yp>=windY) L = rayLenTmp;
  847.         
  848.         while (L<rayLenTmp)
  849.         {
  850.  
  851.         if ( *(theTemp + MrBlobby ) > (z >> heightShift) )
  852.             {
  853.             *(unsigned short*)(offScreen2) = 
  854.             *(unsigned short*)(theTemp3 + (((long)*(theTemp2 + MrBlobby)) << 11) + (L << 2));
  855.             
  856.             offScreen2    -= windXstep;
  857.  
  858.             yp    += yStep;
  859.             yztemp = yp + yOffSet2;
  860.             yv = yztemp << 1;
  861.             
  862.             z = hhhh + (yztemp * L);
  863.             if (yp>=windY) goto end2;
  864.             }
  865.             else
  866.             {
  867.                 L += 2;
  868.                 x += xv;
  869.                 y += zv;
  870.                 z += yv;
  871.                 MrBlobby = mrBlob1;
  872.             }
  873.         }
  874.         
  875.         yv    =    yv << 1;
  876.         xv    =    xv << 1;
  877.         zv    =    zv << 1;
  878.         
  879.         rayLenTmp = rayLen;
  880.         
  881.         if (yp>=windY) goto end2;
  882.         while (L<rayLenTmp)
  883.         {
  884.  
  885.         if ( *(theTemp + MrBlobby ) > (z >> heightShift) )
  886.             {
  887.             *(unsigned short*)(offScreen2) = 
  888.             *(unsigned short*)(theTemp3 + (((long)*(theTemp2 + MrBlobby)) << 11) + (L << 2));
  889.             
  890.             offScreen2    -= windXstep;
  891.             yp += yStep;
  892.             
  893.             yztemp = yp + yOffSet2;
  894.             yv    =    yztemp << 2;
  895.             
  896.             z = hhhh + (yztemp * L);
  897.             if (yp>=windY) L = rayLenTmp;
  898.             }
  899.             else
  900.             {
  901.                 L += 4;
  902.                 x += xv;
  903.                 y += zv;
  904.                 z += yv;
  905.                 MrBlobby = mrBlob1;
  906.             }
  907.         }
  908.     
  909.     end2:
  910.     xp2    += 2;
  911.     xp    += 2;
  912.     xOffSet += xChng;
  913.     xOffSetdiv = xOffSet >> 8;
  914.     }
  915.     copyOffScreen();
  916.     clearOffScreen();
  917. }
  918.  
  919. void ToDrawX4(void)
  920. {
  921. long     xp, yp, xp2;
  922. long    L;
  923. long    x, y;
  924. long    xv, zv;
  925. long    z, yv, yvc;
  926. Ptr        offScreen2;
  927. unsigned short    MrBlobby;
  928. long    rayLenTmp;
  929. long    xOffSet, xOffSetdiv, xChng, yOffSet2;
  930.  
  931. xp     = -windX;
  932. xp2    = 0;
  933. xChng = -((xres2 - mx2) >> 2);
  934. xOffSet = xp * xChng;
  935. xOffSetdiv = xOffSet >> 8;
  936. xChng = xChng << 2;
  937.  
  938. while (xp < windX)
  939.     {
  940.  
  941.     x    =    xxxx;
  942.     y    =    yyyy;
  943.     z    =    hhhh + (xOffSet >> 8);
  944.  
  945.     yp    =     -windY;
  946.     L    =      0;
  947.     offScreen2 = offScreen + xp2 + (((windY2-1) * windX2));
  948.     
  949.     xv    =    (long)(cs[angle] - ((xp * sn[angle]) >> 8) );
  950.     zv    =    (long)(sn[angle] + ((xp * cs[angle]) >> 8) );
  951.     yvc = 0;
  952.     yv    =    yp - yOffSet - (xOffSet >> 8);
  953.     yOffSet2 = - yOffSet - xOffSetdiv;
  954.  
  955.     rayLenTmp = 127;
  956.     if (rayLen < rayLenTmp) rayLenTmp = rayLen;
  957.     MrBlobby = mrBlob1;
  958.  
  959.     loop41:
  960.         {                        
  961.  
  962.         if ( *(theTemp + MrBlobby ) > (z >> heightShift) )
  963.             {
  964.             *(long*)(offScreen2) = 
  965.             *(long*)(theTemp3 + (((long)*(theTemp2 + MrBlobby)) << 11) + (L << 2));
  966.             
  967.             offScreen2    -= windXstep;
  968.  
  969.             yp += yStep;
  970.             yv += yStep;
  971.             z += yvc;
  972.             if (yp >= windY) goto end43;
  973.             }
  974.             else
  975.             {
  976.                 L++;
  977.                 if (L >= rayLenTmp) goto end41;
  978.                 z += yv;
  979.                 x += xv;
  980.                 y += zv;
  981.                 yvc += yStep;
  982.                 MrBlobby = mrBlob1;
  983.             }
  984.         }
  985.         goto loop41;
  986.         end41:
  987.         yv    =    yv << 1;
  988.         xv    =    xv << 1;
  989.         zv    =    zv << 1;
  990.         
  991.         rayLenTmp = 255;
  992.         if (rayLen < rayLenTmp) rayLenTmp = rayLen;
  993.         
  994.         loop42:
  995.         {
  996.         if ( *(theTemp + MrBlobby ) > (z >> heightShift) )
  997.             {
  998.             *(unsigned long*)(offScreen2) = 
  999.             *(unsigned long*)(theTemp3 + (((long)*(theTemp2 + MrBlobby)) << 11) + (L << 2));
  1000.             
  1001.             offScreen2    -= windXstep;
  1002.  
  1003.             yp    += yStep;
  1004.             yv = (yp + yOffSet2) << 1;
  1005.             
  1006.             z += yvc;
  1007.  
  1008.             if (yp>=windY) goto end43;
  1009.             }
  1010.             else
  1011.             {
  1012.                 L += 2;
  1013.                 if (L >= rayLenTmp) goto end42;
  1014.                 x += xv;
  1015.                 y += zv;
  1016.                 z += yv;
  1017.                 yvc += (yStep << 1);
  1018.                 MrBlobby = mrBlob2;
  1019.             }
  1020.         }
  1021.         goto loop42;
  1022.         
  1023.         end42:
  1024.         yv    =    yv << 1;
  1025.         xv    =    xv << 1;
  1026.         zv    =    zv << 1;
  1027.         
  1028.         rayLenTmp = rayLen;
  1029.         
  1030.         loop43:
  1031.         {
  1032.  
  1033.         if ( *(theTemp + MrBlobby ) > (z >> heightShift) )
  1034.             {
  1035.             *(unsigned long*)(offScreen2) = 
  1036.             *(unsigned long*)(theTemp3 + (((long)*(theTemp2 + MrBlobby)) << 11) + (L << 2));
  1037.             
  1038.             offScreen2    -= windXstep;
  1039.             yp += yStep;
  1040.  
  1041.             yv    =    (yp + yOffSet2) << 2;
  1042.             
  1043.             z += yvc;
  1044.  
  1045.             if (yp>=windY) goto end43;
  1046.             }
  1047.             else
  1048.             {
  1049.                 L += 4;
  1050.                 if (L >= rayLenTmp) goto end43;
  1051.                 x += xv;
  1052.                 y += zv;
  1053.                 z += yv;
  1054.                 yvc += (yStep << 2);
  1055.                 MrBlobby = mrBlob3;
  1056.             }
  1057.         }
  1058.     goto loop43;
  1059.     end43:
  1060.  
  1061.     xp2    += 4;
  1062.     xp    += 4;
  1063.     xOffSet += xChng;
  1064.     xOffSetdiv = xOffSet >> 8;
  1065.     }
  1066.     copyOffScreen();
  1067.     clearOffScreen();
  1068. }
  1069.  
  1070. void DoPreferences(void)
  1071. {
  1072. Boolean         itsDone;
  1073. DialogPtr        theDialog, theDialog2;
  1074. short            itemHit, itemHit2;
  1075. Rect            iRect;
  1076. Point             tempPoint;
  1077. Rect            tempRect;
  1078. StringHandle    string;
  1079.  
  1080. short            WindowSizeError, WindowSizeTemp;
  1081. short            PixelSizeError, PixelSizeTemp;
  1082. short            LandScapeError, LandScapeTemp;
  1083. short            RayLenError, RayLenTemp;
  1084.  
  1085. ControlHandle    WindSizeCtrl, PixSizeCtrl, LandCtrl, RayLenCtrl;
  1086. MenuHandle        WindSizeMenu, LandMenu, PixSizeMenu, RayLenMenu;
  1087.  
  1088. ShowCursor();
  1089.  
  1090. string = NewHandle(256);
  1091.  
  1092. theDialog = GetNewDialog(133, nil, EliteWindow);
  1093.  
  1094. if (theDialog == 0) DoError(4 ,TRUE);
  1095.  
  1096. SetPort(theDialog);
  1097.  
  1098. CenterDialog(theDialog, theScreen);
  1099. BringToFront(theDialog);
  1100. DrawDialog(theDialog);
  1101.  
  1102. tempRect = GetDRect(theDialog, mWindSize);
  1103. WindSizeCtrl = NewControl(theDialog, &tempRect, "", TRUE, 1, WindSizeMnu, 0, (1008 + 5), WindSizeMnu);
  1104. if (WindSizeCtrl == 0) DoError(18 ,TRUE);
  1105.  
  1106. WindSizeMenu = GetMenu(WindSizeMnu);
  1107. if (WindSizeMenu == 0) DoError(1 ,TRUE);
  1108. InsertMenu(WindSizeMenu, -1);
  1109.  
  1110. if (theScreen.resolutionX < 640) DisableItem(WindSizeMenu, 6);
  1111. if (theScreen.resolutionX < 640) DisableItem(WindSizeMenu, 5);
  1112. if (theScreen.resolutionX < 512) DisableItem(WindSizeMenu, 4);
  1113. if (theScreen.resolutionX < 400) DisableItem(WindSizeMenu, 3);
  1114. if (theScreen.resolutionX < 320) DisableItem(WindSizeMenu, 2);
  1115. if (theScreen.resolutionX < 160) DisableItem(WindSizeMenu, 1);
  1116.  
  1117. if (theScreen.resolutionY < 480) DisableItem(WindSizeMenu, 6);
  1118. if (theScreen.resolutionY < 400) DisableItem(WindSizeMenu, 5);
  1119. if (theScreen.resolutionY < 384) DisableItem(WindSizeMenu, 4);
  1120. if (theScreen.resolutionY < 300) DisableItem(WindSizeMenu, 3);
  1121. if (theScreen.resolutionY < 240) DisableItem(WindSizeMenu, 2);
  1122. if (theScreen.resolutionY < 120) DisableItem(WindSizeMenu, 1);
  1123.  
  1124. tempRect = GetDRect(theDialog, mPixelSize);
  1125. PixSizeCtrl = NewControl(theDialog, &tempRect, "", TRUE, 1, PixSizeMnu, 0, (1008 + 5), WindSizeMnu);
  1126. if (PixSizeCtrl == 0) DoError(18 ,TRUE);
  1127.  
  1128. PixSizeMenu = GetMenu(PixSizeMnu);
  1129. if (PixSizeMenu == 0) DoError(1 ,TRUE);
  1130. InsertMenu(PixSizeMenu, -1);
  1131.  
  1132. tempRect = GetDRect(theDialog, mLandscape);
  1133. LandCtrl = NewControl(theDialog, &tempRect, "", TRUE, 1, LandMnu, 0, (1008 + 5), WindSizeMnu);
  1134. if (LandCtrl == 0) DoError(18 ,TRUE);
  1135.  
  1136. LandMenu = GetMenu(LandMnu);
  1137. if (LandMenu == 0) DoError(1 ,TRUE);
  1138. InsertMenu(LandMenu, -1);
  1139.  
  1140. tempRect = GetDRect(theDialog, mRayLength);
  1141. RayLenCtrl = NewControl(theDialog, &tempRect, "", TRUE, 1, RayLenMnu, 0, (1008 + 5), WindSizeMnu);
  1142. if (RayLenCtrl == 0) DoError(18 ,TRUE);
  1143.  
  1144. RayLenMenu = GetMenu(RayLenMnu);
  1145. if (RayLenMenu == 0) DoError(1 ,TRUE);
  1146. InsertMenu(RayLenMenu, -1);
  1147.  
  1148. SetTheInfo(theDialog, tRandSeed, randSeed);
  1149. SetTheInfo(theDialog, tWaterLevel, waterLevel);
  1150. SetCtlValue(PixSizeCtrl, (short)PixelSizeOption);
  1151. SetCtlValue(WindSizeCtrl, (short)WindowSizeOption);
  1152. SetCtlValue(LandCtrl, (short)LandScapeOption);
  1153. SetCtlValue(RayLenCtrl, (short)RayLengthOption);
  1154.  
  1155. tempRect = GetDRect( theDialog, 18);
  1156. FrameRect(&tempRect);
  1157.  
  1158. itsDone = FALSE;
  1159.  
  1160. FlushEvents(everyEvent, REMOVE_ALL_EVENTS);
  1161.  
  1162.     while(!itsDone)
  1163.     {
  1164.         ModalDialog(nil, &itemHit);
  1165.         if (itemHit == bOK)     {
  1166.                                 itsDone = TRUE;
  1167.                                 }
  1168.         
  1169.         if (itemHit == bQuit)     {
  1170.                                 Quit();
  1171.                                 }
  1172.  
  1173.         if (itemHit == bAbout)     {
  1174.                                 FlushEvents(everyEvent, REMOVE_ALL_EVENTS);
  1175.                                 theDialog2 = GetNewDialog(8000, nil, EliteWindow);
  1176.                                 CenterDialog(theDialog2, theScreen);
  1177.                                 BringToFront(theDialog2);
  1178.                                 itemHit2 = 1;
  1179.                                 while(itemHit2 != 2) { ModalDialog(nil, &itemHit2); }
  1180.                                 DisposDialog(theDialog2);
  1181.                                 FlushEvents(everyEvent, REMOVE_ALL_EVENTS);
  1182.                                 tempRect = GetDRect( theDialog, 18);
  1183.                                 FrameRect(&tempRect);
  1184.                                 }
  1185.  
  1186.         if (itemHit == bRandomize){
  1187.                                 qd.randSeed = (unsigned long)TickCount();
  1188.                                 randSeed = Random() + 32767;
  1189.                                 if (randSeed == 0) randSeed = 1;
  1190.                                 SetTheInfo(theDialog, tRandSeed, randSeed);
  1191.                                 }
  1192.  
  1193.         if (itemHit == mWindSize){
  1194.                                     WindowSizeError = WindowSizeOption;
  1195.                                     iRect = GetDRect(theDialog, mWindSize);
  1196.                                     tempPoint.v = iRect.top;
  1197.                                     tempPoint.h = iRect.left;
  1198.                                     LocalToGlobal(&tempPoint);
  1199.                                     WindowSizeTemp = PopUpMenuSelect(WindSizeMenu, tempPoint.v, tempPoint.h, WindowSizeOption);
  1200.                                     if (WindowSizeTemp != 0) WindowSizeOption = WindowSizeTemp;
  1201.                                     SetCtlValue(WindSizeCtrl, (short)WindowSizeOption);
  1202.                                 }
  1203.  
  1204.         if (itemHit == mPixelSize){
  1205.                                     PixelSizeError = PixelSizeOption;
  1206.                                     iRect = GetDRect(theDialog, mPixelSize);
  1207.                                     tempPoint.v = iRect.top;
  1208.                                     tempPoint.h = iRect.left;
  1209.                                     LocalToGlobal(&tempPoint);
  1210.                                     PixelSizeTemp = PopUpMenuSelect(PixSizeMenu, tempPoint.v, tempPoint.h, PixelSizeOption);
  1211.                                     if (PixelSizeTemp != 0) PixelSizeOption = PixelSizeTemp;
  1212.                                     SetCtlValue(PixSizeCtrl, (short)PixelSizeOption);
  1213.                                 }
  1214.  
  1215.         if (itemHit == mLandscape){
  1216.                                     LandScapeError = LandScapeOption;
  1217.                                     iRect = GetDRect(theDialog, mLandscape);
  1218.                                     tempPoint.v = iRect.top;
  1219.                                     tempPoint.h = iRect.left;
  1220.                                     LocalToGlobal(&tempPoint);
  1221.                                     LandScapeTemp = PopUpMenuSelect(LandMenu, tempPoint.v, tempPoint.h, LandScapeOption);
  1222.                                     if (LandScapeTemp != 0) LandScapeOption = LandScapeTemp;
  1223.                                     SetCtlValue(LandCtrl, (short)LandScapeOption);
  1224.                                 }
  1225.  
  1226.         if (itemHit == mRayLength){
  1227.                                     RayLenError = RayLengthOption;
  1228.                                     iRect = GetDRect(theDialog, mRayLength);
  1229.                                     tempPoint.v = iRect.top;
  1230.                                     tempPoint.h = iRect.left;
  1231.                                     LocalToGlobal(&tempPoint);
  1232.                                     RayLenTemp = PopUpMenuSelect(RayLenMenu, tempPoint.v, tempPoint.h, RayLengthOption);
  1233.                                     if (RayLenTemp != 0) RayLengthOption = RayLenTemp;
  1234.                                     SetCtlValue(RayLenCtrl, (short)RayLengthOption);
  1235.                                 }
  1236.     }
  1237.  
  1238. GetTheInfoStr(theDialog, tRandSeed, string);
  1239. StringToNum(*string, &randSeed);
  1240.  
  1241. GetTheInfoStr(theDialog, tWaterLevel, string);
  1242. StringToNum(*string, &waterLevel);
  1243.  
  1244. if (randSeed == 0) randSeed = 1;
  1245.  
  1246. tempPoint.v = 0;
  1247. tempPoint.h = 0;
  1248. ShieldCursor(&theScreen.screenRect, tempPoint);
  1249.  
  1250. DisposHandle(string);
  1251.  
  1252. switch (WindowSizeOption) {
  1253.  
  1254.                 case 1:    {    windX = 80;
  1255.                             windY = 60;
  1256.                         }     break;
  1257.  
  1258.                 case 2:    {    windX = 160;
  1259.                             windY = 120;
  1260.                         }     break;
  1261.  
  1262.                 case 3:    {    windX = 200;
  1263.                             windY = 150;
  1264.                         }     break;
  1265.  
  1266.                 case 4:    {    windX = 256;
  1267.                             windY = 192;
  1268.                         }     break;
  1269.  
  1270.                 case 5:    {    windX = 320;
  1271.                             windY = 200;
  1272.                         }     break;
  1273.  
  1274.                 case 6:    {    windX = 320;
  1275.                             windY = 240;
  1276.                         }     break;
  1277.                         
  1278.                         }
  1279.  
  1280. switch (PixelSizeOption) {
  1281.  
  1282.                 case 1:    {    xStep = 1;
  1283.                             yStep = 1;
  1284.                         }     break;
  1285.  
  1286.                 case 2:    {    xStep = 2;
  1287.                             yStep = 1;
  1288.                         }     break;
  1289.  
  1290.                 case 3:    {    xStep = 2;
  1291.                             yStep = 2;
  1292.                         }     break;
  1293.  
  1294.                 case 4:    {    xStep = 4;
  1295.                             yStep = 2;
  1296.                         }     break;
  1297.  
  1298.                 case 5:    {    xStep = 4;
  1299.                             yStep = 4;
  1300.                         }     break;
  1301.                         
  1302.                         }
  1303.                         
  1304. switch (RayLengthOption) {
  1305.  
  1306.                 case 1:    {    rayLen = 128;
  1307.                         }     break;
  1308.  
  1309.                 case 2:    {    rayLen = 200;
  1310.                         }     break;
  1311.  
  1312.                 case 3:    {    rayLen = 256;
  1313.                         }     break;
  1314.  
  1315.                 case 4:    {    rayLen = 320;
  1316.                         }     break;
  1317.  
  1318.                 case 5:    {    rayLen = 400;
  1319.                         }     break;
  1320.  
  1321.                 case 6:    {    rayLen = 512;
  1322.                         }     break;
  1323.  
  1324.                         }
  1325. pNum = LandScapeOption;
  1326. }
  1327.  
  1328. void Quit(void)
  1329. {
  1330.     ShowCursor();
  1331.     ShowMenuBar();
  1332.     MemEnd();
  1333.     FlushEvents(everyEvent, REMOVE_ALL_EVENTS);
  1334.     ChangeBitDepth(oldBitDepth,1);
  1335.     ExitToShell();
  1336. }